package session;

import javax.ejb.*;
import javax.persistence.*;
import javax.naming.*;
import java.io.File;
import java.util.ArrayList;
import java.util.Date;
import java.util.List;
import entity.*;
import java.io.*;
import java.util.*;
import java.util.logging.Level;
import java.util.logging.Logger;
//import java.sql.Date;

@Stateful(mappedName = "leBeanManager")
//@EJB(name="ejb/ElectionManagementBean",beanInterface=ElectionManagementItf.class,beanName="leBeanManager")
public class ElectionManagementBean implements ElectionManagementItf {

    @PersistenceContext(unitName = "ProjetSI2PU")
    private EntityManager em;

    @Override   //OK 
    public boolean modifierMDP(String login, String nvmdp) {
        boolean succes = false;
        Acteur monacteur = null;
        // On part du principe que les login sont uniques
        Query mareq = em.createQuery("select a from Acteur a where a.login=:param").setParameter("param", login);

        try {
            monacteur = (Acteur) mareq.getSingleResult();
        } catch (NoResultException nre) {
            nre.printStackTrace();
        } finally {
            if (monacteur != null) {
                monacteur.setMdp(nvmdp);
                em.persist(monacteur);
                succes = true;
            }
            return succes;
        }

    }

    @Override
    //Guillaume
    public Map<Integer, String> consulterCollegesElection(int idElection) {
        Map<Integer, String> colleges = null;
        Election e = em.find(Election.class, idElection);
        List<College> collegesElection = e.getColleges();
        if (e != null) {
            colleges = new HashMap<Integer, String>();
            for (College c : collegesElection) {
                colleges.put(c.getIdcollege(), c.getLibelle());
            }
        }
        return colleges;
    }

    @Override
    //Guillaume
    public Map<Integer, List<String>> consulterElecteursCollege(int idCollege) {
        Map<Integer, List<String>> electeurs = null;
        College c = em.find(College.class, idCollege);
        List<String> infosElecteur;
        if (c != null) {
            electeurs = new HashMap<Integer, List<String>>();
            for (Electeur e : c.getElecteurs()) {
                infosElecteur = new ArrayList<String>();
                infosElecteur.add(e.getNom());
                infosElecteur.add(e.getPrenom());
                electeurs.put(e.getIdelecteur(), infosElecteur);
            }
        }
        return electeurs;
    }

    @Override
    //Guillaume
    public void Imprimer(int idElection) {
        // TODO Auto-generated method stub	
    }

    @Override
    //Guillaume
    //exporte une liste d'�lection via un fichier excel: Later
    public File exporter(int idElection, String path) {
        // TODO Auto-generated method stub
        Election el = em.find(Election.class, idElection);
        if (el != null) {
            List<Participe> lp = el.getParticipes();
            List<Electeur> le = new ArrayList<Electeur>();
            BufferedWriter bw = null;
            for (Participe p : lp) {
                le.add(p.getElecteur());
            }
            File resultat = new File("Z:/list.csv");
            try {
                bw = new BufferedWriter(new FileWriter(resultat));
                bw.write(el.getLibelle() + ";");
                bw.newLine();
                bw.write("Prenom;Nom;Presence;");
                bw.newLine();
                for (Electeur e : le) {
                    bw.write(e.getPrenom() + ";" + e.getNom() + ";" + " ;");
                    bw.newLine();
                }
                bw.close();
            } catch (IOException ex) {
                ex.printStackTrace();
            }
            if (bw != null) {
                return resultat;
            } else {
                return null;
            }
        } else {
            return null;
        }
    }
    
    

    @Override //OK mais probleme avec la date
    //Guillaume
    public boolean creerElection(String libelle, Date deb, Date fin,
            List<Integer> burList, List<Integer> colgList) {
        Election result = null;
        List<Bureau> bureaux;
        List<College> colleges;
        // TODO Auto-generated method stub
        Query marq = em.createQuery("select elec.datedebut, elec.datefin, elec.libelle from Election elec "
                + "where elec.datedebut=:param1 AND elec.datefin=:param2 AND elec.libelle=:param3 ").
                setParameter("param1", deb).
                setParameter("param2", fin).
                setParameter("param3", libelle);
        try {
            result = (Election) marq.getSingleResult();
        } catch (NoResultException nd) {
            nd.printStackTrace();
        } finally {
            if (result == null) {
                Election elec = new Election();
                elec.setLibelle(libelle);
                elec.setDatedebut(deb);
                elec.setDatefin(fin);
                bureaux = new ArrayList<Bureau>();
                colleges = new ArrayList<College>();
                for (int b : burList) {
                    if (em.find(Bureau.class, b) != null) {
                        bureaux.add(em.find(Bureau.class, b));
                    }
                }
                for (int c : colgList) {
                    if (em.find(College.class, c) != null) {
                        colleges.add(em.find(College.class, c));
                    }
                }
                elec.setBureaus(bureaux);
                elec.setColleges(colleges);
                em.persist(elec);
                return true;
            } else {
                return false;
            }
        }
    }

    @Override // OK
    //In�s
    public boolean creerBureau(String nom, String adresse, String houv, String hfin) {
        boolean resultat = false;
        Bureau result = null;
        Query createBur = em.createQuery("select b from Bureau b  where b.nom=:param1"
                + " AND b.adresse=:param2 AND b.heureouverture=:param3 AND b.heurefermeture=:param4").
                setParameter("param1", nom).
                setParameter("param2", adresse).
                setParameter("param3", houv).
                setParameter("param4", hfin);

        try {
            result = (Bureau) createBur.getSingleResult();
        } catch (NoResultException nre) {
            nre.printStackTrace();
        } finally {
            if (result == null) {
                Bureau bur = new Bureau();
                bur.setNom(nom);
                bur.setAdresse(adresse);
                bur.setHeureouverture(houv);
                bur.setHeurefermeture(hfin);
                em.persist(bur);
                resultat = true;
            }
            //else resultat = false;
        }
        return resultat;
    }

    @Override //OK
    //In�s
    public boolean modifierBureau(int idbur, String nom, String adresse, String houv, String hfin) {
        Bureau bur = em.find(Bureau.class, idbur);
        if (bur != null) {
            bur.setNom(nom);
            bur.setAdresse(adresse);
            bur.setHeureouverture(houv);
            bur.setHeurefermeture(hfin);
            em.persist(bur);
            return true;
        } else {
            return false;
        }

    }

    @Override //OK
    //Guillaume
    public boolean modifierElecteur(int idElecteur, String nom, String prenom, Date datenaiss,
            String composante, String adresse) {
        Electeur el = em.find(Electeur.class, idElecteur);
        if (el != null) {
            el.setNom(nom);
            el.setPrenom(prenom);
            el.setDatenaissance(datenaiss);
            el.setComposante(composante);
            el.setAdresse(adresse);
            em.persist(el);
            return true;
        } else {
            return false;
        }
    }

    @Override
    //Later
    public boolean envoyerMail(String message, int idActeur) {
        // TODO Auto-generated method stub
        return false;
    }

    //Guillaume
    @Override
    public boolean verifLogin(String login) {
        boolean resultat = false;
        Acteur a = null;
        Query reqlogin = em.createQuery("select a from Acteur a where a.login=:param1").setParameter("param1", login);
        try {
            a = (Acteur) (reqlogin.getSingleResult());
        } catch (NoResultException nre) {
            nre.printStackTrace();
        } finally {
            if (a == null) {
                resultat = true;
            }
        }
        return resultat;
    }

    @Override //OK
    //Estelle
    public boolean creerActeur(String nom, String prenom, String login, String mdp, int idProfil) {
        boolean resultat = false;
        Acteur monacteur = null;
        Profil p = em.find(Profil.class, idProfil);
        //On vérifie que l'utilisateur n'existe pas déjà en BD
        Query req = em.createQuery("select a from Acteur a where a.nom=:param1"
                + " AND a.prenom=:param2 AND a.login=:param3 ").
                setParameter("param1", nom).
                setParameter("param2", prenom).
                setParameter("param3", login);

        try {
            monacteur = (Acteur) req.getSingleResult();
        } catch (NoResultException nre) {
            nre.printStackTrace();
        } finally {
            if (p != null && monacteur == null) {
                Acteur newacteur = new Acteur();
                newacteur.setNom(nom);
                newacteur.setPrenom(prenom);
                newacteur.setLogin(login);
                newacteur.setMdp(mdp);
                newacteur.setProfil(p);
                p.getActeurs().add(newacteur);
                em.persist(newacteur);
                resultat = true;
            }
        }

        return resultat;
    }

    @Override //OK
    //Estelle 
    public boolean supprimerActeur(int idActeur) {
        boolean succes = false;
        Acteur monacteur = null;
        Query mareq = em.createQuery("select a from Acteur a where a.idacteur=:param").setParameter("param", idActeur);

        try {

            monacteur = (Acteur) mareq.getSingleResult();

        } catch (NoResultException nre) {
            nre.printStackTrace();
        } finally {
            if (monacteur != null) {
                int cle = monacteur.getIdacteur();
                Profil p = monacteur.getProfil();
                p.getActeurs().remove(monacteur);
                em.remove(monacteur);
                Acteur a = em.find(Acteur.class, cle);
                if (a == null) {
                    succes = true;
                }
            }
        }
        return succes;
    }

    @Override //NOK à voir si les dates utilisées ne devraient pas être de la classe SQL.Date pour fonctionner
    public boolean modifierElection(int id_Elec, String libelle, Date deb,
            Date fin) {
        // TODO Auto-generated method stub
        //Nafi
        Election el = em.find(Election.class, id_Elec);
        if (el != null) {
            el.setLibelle(libelle);
            el.setDatedebut(deb);
            el.setDatefin(fin);
            em.persist(el);
            return true;
        }
        return false;
    }

    @Override //OK
    public boolean modifierActeur(int id_Act, String nom, String prenom, String login, String mdp, int idProfil) {
        Acteur newActeur = null;
        boolean resultat = false;
        Profil profil = em.find(Profil.class, idProfil);
        Query req = em.createQuery("select a from Acteur a where a.nom=:param1"
                + " AND a.prenom=:param2 AND a.login=:param3 ").
                setParameter("param1", nom).
                setParameter("param2", prenom).
                setParameter("param3", login);
        try {
            newActeur = (Acteur) (req.getSingleResult());
        } catch (NoResultException e) {
            e.printStackTrace();
        } finally {
            if (newActeur == null) {
                newActeur = em.find(Acteur.class, id_Act);
                if (newActeur != null) {
                    newActeur.setNom(nom);
                    newActeur.setPrenom(prenom);
                    newActeur.setLogin(login);
                    newActeur.setMdp(mdp);
                    newActeur.setProfil(profil);
                    em.persist(newActeur);
                    resultat = true;
                }
            }
            return resultat;
        }



    }

    //Guillaume 
    @Override //OK 
    public Map<String, Object> consulterElection(int idelec) {
        // consulter la liste des bureaux, colleges et electeurs
        Election elec = em.find(Election.class, idelec);
        Map<String, Object> infosElection;
        List<String> infoColleges;
        List<String> infoBureaux;
        if (elec != null) {
            infosElection = new HashMap<String, Object>();
            infoColleges = new ArrayList<String>();
            infoBureaux = new ArrayList<String>();
            infosElection.put("libelle", elec.getLibelle());
            infosElection.put("idElection", elec.getIdelection());
            infosElection.put("dateDebut", elec.getDatedebut());
            infosElection.put("dateFin", elec.getDatefin());
            for (int i = 0; i < elec.getBureaus().size(); i++) {
                infoBureaux.add(elec.getBureaus().get(i).getNom());
            }
            for (int i = 0; i < elec.getColleges().size(); i++) {
                infoColleges.add(elec.getColleges().get(i).getLibelle());
            }
            infosElection.put("bureaux", infoBureaux);
            infosElection.put("colleges", infoColleges);
            return infosElection;
        } else {
            return null;
        }
    }

    // Guillaume Ok
    @Override
    public Map<Integer, String> consulterElections() {
        Query req = em.createQuery("select e.idelection, e.libelle from Election e");
        Map<Integer, String> infoElections = null;
        try {
            List results = req.getResultList();
            infoElections = new HashMap<Integer, String>();
            for (Object r : results) {
                Object[] ligne = (Object[]) r;
                infoElections.put((Integer) ligne[0], (String) ligne[1]);
            }
        } catch (NoResultException nre) {
            nre.printStackTrace();
        } finally {
            return infoElections;
        }

    }

    // Guillaume Ok
    @Override
    public Map<Integer, String> consulterBureaux() {
        Query req = em.createQuery("select b.idbureau, b.nom from Bureau b");
        Map<Integer, String> infoBureaux = null;
        try {
            List results = req.getResultList();
            infoBureaux = new HashMap<Integer, String>();
            for (Object r : results) {
                Object[] ligne = (Object[]) r;
                infoBureaux.put((Integer) ligne[0], (String) ligne[1]);
            }
        } catch (NoResultException nre) {
            nre.printStackTrace();
        } finally {
            return infoBureaux;
        }

    }

    // Guillaume Ok
    @Override
    public Map<Integer, String> consulterColleges() {
        Query req = em.createQuery("select c.idcollege, c.libelle from College c");
        Map<Integer, String> infoColleges = null;
        try {
            List results = req.getResultList();
            infoColleges = new HashMap<Integer, String>();
            for (Object r : results) {
                Object[] ligne = (Object[]) r;
                infoColleges.put((Integer) ligne[0], (String) ligne[1]);
            }
        } catch (NoResultException nre) {
            nre.printStackTrace();
        } finally {
            return infoColleges;
        }

    }

    // Guillaume Ok
    @Override
    public Map<Integer, List<String>> consulterElecteurs() {
        Query req = em.createQuery("select e.idelecteur, e.nom, e.prenom from Electeur e");
        Map<Integer, List<String>> infoElecteurs = null;
        List<String> l;
        try {
            List results = req.getResultList();
            infoElecteurs = new HashMap<Integer, List<String>>();
            for (Object r : results) {
                l = new ArrayList<String>();
                Object[] ligne = (Object[]) r;
                l.add((String) ligne[1]);
                l.add((String) ligne[2]);
                infoElecteurs.put((Integer) ligne[0], l);
            }
        } catch (NoResultException nre) {
            nre.printStackTrace();
        } finally {
            return infoElecteurs;
        }
    }

    @Override //Guillaume
    public boolean importer(File f) {
        // TODO Auto-generated method stub
        return false;
    }

    @Override //OK - Guillaume
    public int authActeur(String login, String mdp) {
        Acteur monacteur = null;
        Query mareq = em.createQuery("select a from Acteur a where a.login=:param1").
                setParameter("param1", login);
        try {
            monacteur = (Acteur) mareq.getSingleResult();
        } catch (NoResultException nre) {
            nre.printStackTrace();
        } finally {
            if (monacteur != null && monacteur.getMdp().toString().equals(mdp.toString())) {
                return monacteur.getIdacteur();
            } else {
                return -1;
            }
        }

    }

    @Override //OK - Guillaume
    public boolean majRoleActeur(int idacteur, int idprofil) {
        boolean succes = false;
        Acteur a = em.find(Acteur.class, idacteur);
        Profil p = em.find(Profil.class, idprofil);

        if (a != null && p != null) {
            a.setProfil(p);
            em.persist(a);
            succes = true;
        }
        return succes;

    }

    @Override //OK - Guillaume
    public Map<String, Object> consulterActeur(int idActeur) {
        Acteur a = em.find(Acteur.class, idActeur);
        Map<String, Object> infosActeur = null;
        if (a != null) {
            infosActeur = new HashMap<String, Object>();
            infosActeur.put("login", a.getLogin());
            infosActeur.put("mdp", a.getMdp());
            infosActeur.put("nom", a.getNom());
            infosActeur.put("prenom", a.getPrenom());
            infosActeur.put("idProfil", a.getProfil().getIdprofil());
            infosActeur.put("libelleProfil", a.getProfil().getLibelleprofil());
        }
        return infosActeur;

    }

    @Override
    public Map<Integer, String> consulterProfils() {
        Query req = em.createQuery("select p.idprofil, p.libelleprofil from Profil p");
        Map<Integer, String> infoProfils = null;
        try {
            List results = req.getResultList();
            infoProfils = new HashMap<Integer, String>();
            for (Object r : results) {
                Object[] ligne = (Object[]) r;
                infoProfils.put((Integer) ligne[0], (String) ligne[1]);
            }
        } catch (NoResultException nre) {
            nre.printStackTrace();
        } finally {
            return infoProfils;
        }
    }

    @Override
    public boolean ajouterCollegeElection(int idElection, int idCollege) {
        Election el = em.find(Election.class, idElection);
        College c = em.find(College.class, idCollege);
        if (el != null && c != null && !el.getColleges().contains(c)) {
            List<College> listCol = el.getColleges();
            List<Election> listEl = c.getElections();
            listCol.add(c);
            listEl.add(el);
            el.setColleges(listCol);
            c.setElections(listEl);
            em.persist(el);
            em.persist(c);
            this.ajouterElecteursElection(idElection, idCollege);
            return true;
        } else {
            return false;
        }
    }

    //Guillaume
    @Override
    public boolean creerParticipation(int idElection, int idElecteur) {
        Participe p = null;
        boolean resultat = false;
        if (this.consulterElecteurs().keySet().contains(idElecteur) && this.consulterElections().keySet().contains(idElection)) {
            Query mareq = em.createQuery("select p from Participe p where p.id.refIdelection=:param1 AND p.id.refIdelecteur=:param2").
                    setParameter("param1", idElection).setParameter("param2", idElecteur);
            try {
                p = (Participe) mareq.getSingleResult();
            } catch (NoResultException nre) {
                nre.printStackTrace();
            } finally {
                if (p == null) {
                    ParticipePK ppk = new ParticipePK();
                    ppk.setRefIdelecteur(idElecteur);
                    ppk.setRefIdelection(idElection);
                    p = new Participe();
                    p.setElecteur(em.find(Electeur.class, idElecteur));
                    p.setElection(em.find(Election.class, idElection));
                    p.setPresence(" ");
                    p.setId(ppk);
                    em.persist(p);
                    resultat = true;
                }
            }
        }
        return resultat;

    }

    @Override
    public boolean ajouterElecteursElection(int idElection, int idCollege) {
        boolean resultat = false;
        Election election = em.find(Election.class, idElection);
        College c = em.find(College.class, idCollege);
        List<Participe> elp;
        if (election != null && c != null && election.getColleges().contains(c)) {
            List<Electeur> listEl = c.getElecteurs();
            for (Electeur e : listEl) {
                if (this.creerParticipation(idElection, e.getIdelecteur())) {
                    ParticipePK idParticipe = new ParticipePK();
                    idParticipe.setRefIdelecteur(e.getIdelecteur());
                    idParticipe.setRefIdelection(idElection);
                    elp = e.getParticipes();
                    elp.add(em.find(Participe.class, idParticipe));
                    e.setParticipes(elp);
                    em.persist(e);
                    elp = election.getParticipes();
                    elp.add(em.find(Participe.class, idParticipe));
                    election.setParticipes(elp);
                    em.persist(election);
                }
            }
            resultat = true;
        }
        return resultat;

    }

    @Override
    public boolean ajouterBureauElection(int idElection, int idBureau) {
        Election el = em.find(Election.class, idElection);
        Bureau b = em.find(Bureau.class, idBureau);
        if (el != null && b != null && !el.getBureaus().contains(b)) {
            List<Bureau> listBur = el.getBureaus();
            List<Election> listEl = b.getElections();
            listBur.add(b);
            listEl.add(el);
            el.setBureaus(listBur);
            b.setElections(listEl);
            em.persist(el);
            em.persist(b);
            return true;
        } else {
            return false;
        }
    }

    //Guillaume
    @Override
    public boolean supprimerCollegeElection(int idElection, int idCollege) {
        Election el = em.find(Election.class, idElection);
        College c = em.find(College.class, idCollege);
        if (el != null && c != null) {
            List<College> listCol = el.getColleges();
            List<Election> listEl = c.getElections();
            listCol.remove(c);
            listEl.remove(el);
            el.setColleges(listCol);
            c.setElections(listEl);
            em.persist(el);
            em.persist(c);
            return true;
        } else {
            return false;
        }
    }

    //Guillaume
    @Override
    public boolean supprimerBureauElection(int idElection, int idBureau) {
        Election el = em.find(Election.class, idElection);
        Bureau b = em.find(Bureau.class, idBureau);
        if (el != null && b != null) {
            List<Bureau> listBur = el.getBureaus();
            List<Election> listEl = b.getElections();
            listBur.remove(b);
            listEl.remove(el);
            el.setBureaus(listBur);
            b.setElections(listEl);
            em.persist(el);
            em.persist(b);
            return true;
        } else {
            return false;
        }
    }

    @Override
    public Map<Integer, List<String>> consulterActeurs() {
        Query req = em.createQuery("select a.idacteur, a.nom, a.prenom from Acteur a");
        Map<Integer, List<String>> infoActeurs = null;
        List<String> l;
        try {
            List results = req.getResultList();
            infoActeurs = new HashMap<Integer, List<String>>();
            for (Object r : results) {
                l = new ArrayList<String>();
                Object[] ligne = (Object[]) r;
                l.add((String) ligne[1]);
                l.add((String) ligne[2]);
                infoActeurs.put((Integer) ligne[0], l);
            }
        } catch (NoResultException nre) {
            nre.printStackTrace();
        } finally {
            return infoActeurs;
        }
    }

    //Guillaume 
    @Override //OK 
    public Map<String, Object> consulterBureau(int idbur) {
        // consulter la liste des bureaux, colleges et electeurs
        Bureau bureau = em.find(Bureau.class, idbur);
        Map<String, Object> infosBureau;
        List<Integer> elections;
        if (bureau != null) {
            infosBureau = new HashMap<String, Object>();
            elections = new ArrayList<Integer>();
            infosBureau.put("nom", bureau.getNom());
            infosBureau.put("idBureau", bureau.getIdbureau());
            infosBureau.put("adresse", bureau.getAdresse());
            infosBureau.put("heureFermeture", bureau.getHeurefermeture());
            infosBureau.put("heureOuverture", bureau.getHeureouverture());
            for (int i = 0; i < bureau.getElections().size(); i++) {
                elections.add(bureau.getElections().get(i).getIdelection());
            }
            infosBureau.put("elections", elections);
            return infosBureau;
        } else {
            return null;
        }
    }

    @Override
    public boolean supprimerElection(int idElection) {
        Election el = em.find(Election.class, idElection);
        if (el != null) {
            List<College> listCol = el.getColleges();
            List<Bureau> listBur = el.getBureaus();
            List<Participe> listParElection = el.getParticipes();
            List<Participe> listParElecteur;
            Electeur e;
            List<Election> listEl;
            for (College c : listCol) {
                listEl = c.getElections();
                listEl.remove(el);
                c.setElections(listEl);
                em.persist(c);
            }
            for (Bureau b : listBur) {
                listEl = b.getElections();
                listEl.remove(el);
                b.setElections(listEl);
                em.persist(b);
            }
            for (Participe p : listParElection) {
                e = em.find(Electeur.class, p.getId().getRefIdelecteur());
                listParElecteur = e.getParticipes();
                listParElecteur.remove(p);
                e.setParticipes(listParElecteur);
                em.persist(e);
                em.remove(p);
            }
            em.remove(el);
            return true;
        } else {
            return false;
        }
    }

    @Override
    public boolean creerCollege(File f, String libelle) {
        boolean resultat = false;
        int idCollege;
        BufferedReader br = null;
        if (this.consulterIdCollege(libelle) == -1) {
            this.creerCollege(libelle);
            idCollege = this.consulterIdCollege(libelle);
            Electeur el;
            College col;
            col = em.find(College.class, idCollege);
            List<College> listCol;
            List<Electeur> listEl = col.getElecteurs();
            try {
                br = new BufferedReader(new FileReader(f));
                String line;
                String[] infosEl;
                int year, month, day, idEl;
                br.readLine();
                Date datenaiss;
                while ((line = br.readLine()) != null) {
                    infosEl = line.split(";");
                    //Création de l'electeur
                    year = Integer.parseInt(infosEl[2].split("/")[2])-1900;
                    month = Integer.parseInt(infosEl[2].split("/")[1]) - 1;
                    day = Integer.parseInt(infosEl[2].split("/")[0]);
                    datenaiss = new Date(year, month, day);
                    System.out.println("----------------------------------------------------------------------" + infosEl[0] + infosEl[1] + datenaiss + infosEl[3] + infosEl[4] + Integer.parseInt(infosEl[5]));
                    if (this.creerElecteur(infosEl[0], infosEl[1], datenaiss, infosEl[3], infosEl[4], Integer.parseInt(infosEl[5]))) {
                        idEl = this.consulterIdElecteur(infosEl[0], infosEl[1], datenaiss, infosEl[3], infosEl[4]);
                        el = em.find(Electeur.class, idEl);
                        listEl.add(el);
                        listCol = el.getColleges();
                        listCol.add(col);
                        el.setColleges(listCol);
                        em.persist(el);
                    }

                }
                col.setElecteurs(listEl);
                em.persist(col);
                resultat = true;
            } catch (Exception ex) {
                ex.printStackTrace();
            } finally {
                try {
                    br.close();
                } catch (IOException ex) {
                    ex.printStackTrace();
                }
                return resultat;
            }

        } else {
            return resultat;
        }
    }

    @Override //OK
    //Guillaume
    public boolean creerElecteur(String nom, String prenom, Date datenaiss, String composante, String adresse, int idCategorie) {
        boolean resultat = false;
        Electeur electeur = null;
        Categorie c = em.find(Categorie.class, idCategorie);
        if (c != null && this.consulterIdElecteur(nom, prenom, datenaiss, composante, adresse) == -1) {
            electeur = new Electeur();
            electeur.setNom(nom);
            electeur.setPrenom(prenom);
            electeur.setAdresse(adresse);
            electeur.setCategorie(c);
            electeur.setComposante(composante);
            electeur.setDatenaissance(datenaiss);
            electeur.setColleges(new ArrayList<College>());
            electeur.setParticipes(new ArrayList<Participe>());
            em.persist(electeur);
            resultat = true;
        }


        return resultat;
    }

    //Guillaume
    @Override
    public boolean creerCollege(String libelle) {
        College col = null;
        boolean resultat = false;
        if (this.consulterIdCollege(libelle) == -1) {
            col = new College();
            col.setLibelle(libelle);
            col.setElecteurs(new ArrayList<Electeur>());
            col.setElections(new ArrayList<Election>());
            em.persist(col);
            resultat = true;
        }
        return resultat;
    }

    //Guillaume
    @Override
    public int consulterIdCollege(String libelle) {
        College col = null;
        int idCol = -1;
        Query mareq = em.createQuery("select c from College c where c.libelle=:param1").
                setParameter("param1", libelle);
        try {
            col = (College) mareq.getSingleResult();
        } catch (NoResultException nre) {
            nre.printStackTrace();
        } finally {
            if (col != null) {
                idCol = col.getIdcollege();
            }
            return idCol;
        }
    }

    //Guillaume
    @Override
    public Map<Integer, String> consulterBureauxElection(int idElection) {
        Map<Integer, String> bureaux = null;
        Election e = em.find(Election.class, idElection);
        List<Bureau> bureauxElection = e.getBureaus();
        if (e != null) {
            bureaux = new HashMap<Integer, String>();
            for (Bureau b : bureauxElection) {
                bureaux.put(b.getIdbureau(), b.getNom());
            }
        }
        return bureaux;
    }

    //Ines
    @Override
    public Map<String, Object> consulterElecteur(int idElecteur) {
        Electeur elec = em.find(Electeur.class, idElecteur);
        Map<String, Object> infosElecteur = null;
        if (elec != null) {
            infosElecteur = new HashMap<String, Object>();
            infosElecteur.put("nom", elec.getNom());
            infosElecteur.put("prenom", elec.getPrenom());
            infosElecteur.put("adresse", elec.getAdresse());
            infosElecteur.put("composante", elec.getComposante());
            infosElecteur.put("datenaissance", elec.getDatenaissance());
            infosElecteur.put("categorie", elec.getCategorie().getLibelle());
        }
        return infosElecteur;

    }

    @Override
    public int consulterIdElecteur(String nom, String prenom, Date datenaiss, String composante, String adresse) {
        Electeur e = null;
        int id = -1;
        Query req = em.createQuery("select e from Electeur e where e.nom=:param1"
                + " AND e.prenom=:param2 AND e.adresse=:param3 AND e.composante=:param4"
                + " AND e.datenaissance=:param5").
                setParameter("param1", nom).
                setParameter("param2", prenom).
                setParameter("param3", adresse).
                setParameter("param4", composante).
                setParameter("param5", datenaiss);

        try {
            e = (Electeur) req.getSingleResult();
        } catch (NoResultException nre) {
            nre.printStackTrace();
        } finally {
            if (e != null) {
                id = e.getIdelecteur();
            }
            return id;
        }
    }

    @Override
    public File exporter(int idElection, File f) {
        // TODO Auto-generated method stub
        Election el = em.find(Election.class, idElection);
        if (el != null) {
            List<Participe> lp = el.getParticipes();
            List<Electeur> le = new ArrayList<Electeur>();
            BufferedWriter bw = null;
            for (Participe p : lp) {
                le.add(p.getElecteur());
            }
            
            try {
                bw = new BufferedWriter(new FileWriter(f));
                bw.write(el.getLibelle() + ";");
                bw.newLine();
                bw.write("Prenom;Nom;Presence;");
                bw.newLine();
                for (Electeur e : le) {
                    bw.write(e.getPrenom() + ";" + e.getNom() + ";" + " ;");
                    bw.newLine();
                }
                bw.close();
            } catch (IOException ex) {
                ex.printStackTrace();
            }
            if (bw != null) {
                return f;
            } else {
                return null;
            }
        } else {
            return null;
        }
    }
}
